home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / Drtf / DRichProcess.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  9.3 KB  |  461 lines  |  [TEXT/R*ch]
  1. // DRichProcess.cpp
  2. // d.g.gilbert
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DFile.h"
  7. #include "DRichProcess.h"
  8. #include "DRichViewNu.h"
  9.  
  10. #define rtfmapInternal
  11. #include "rtfmaps.h"
  12. #undef rtfmapInternal
  13.  
  14.  
  15. // struct StyleRec
  16.  
  17. //static DParagraph     gDefParaFmt;
  18. static StyleRec         gDefaultStyle;
  19. static Nlm_Uint4         gLinkcolor;
  20.  
  21. static char        *kDefaultFontname   = "Courier"; //"Times";
  22. static char        *kDefaultFontfamily = "Modern"; //"Roman";    
  23.  
  24.  
  25. StyleRec::StyleRec()
  26. {
  27.     style = DRichStyle();  // DRichStyle constructor handles !?
  28.     fontname= kDefaultFontname;
  29.     fontfamily= kDefaultFontfamily;
  30.     fontsize= DRichprocess::kDefaultFontsize;
  31. }
  32.  
  33.     
  34.     
  35. DRichprocess::DRichprocess( DFile* itsFile, DRichView* itsDoc, Nlm_MonitorPtr progress) :
  36.     fClass(tokUnknown), fMajor(0), fMinor(0), fParam(0),
  37.     fDataFile( itsFile), fDataBuffer( NULL), fDataSize(0), 
  38.     fDoc(itsDoc), fProgress(progress), fParaCount(0),
  39.     fText(NULL), fTextSize(0), fLastTextSize(0), fTextMax(0),
  40.     fLastChar(0), fPushedChar(EOF), fOutMap(NULL),
  41.     fStyleStackSize(0), fTitle(NULL), fNewStyle(true),
  42.     fEndOfData(false)
  43. { 
  44.     fTextMax= 1024;
  45.     fText= (char*) MemNew(fTextMax+1);
  46.  
  47.     fStyleMax= 5;
  48.     fStyleCount= 0;
  49.     fStyleArray= (DRichStyle*) Nlm_MemNew( fStyleMax*sizeof(DRichStyle));
  50.     fStyleStackSize= 0;
  51.  
  52. #if 0
  53.     fStyleRec.style = DRichStyle();
  54.             // don't need this jazz, constructors handle it
  55.     //DRichStyle    aStyle(false);
  56.     //fStyleRec.style= aStyle;
  57.     //fStyleRec.fontname= kDefaultFontname;
  58.     //fStyleRec.fontfamily= kDefaultFontfamily;
  59.     //fStyleRec.fontsize= kDefaultFontsize;
  60. #endif
  61.     fOldStyleRec= fStyleRec;
  62.     gDefaultStyle= fStyleRec;
  63.     
  64.     (void) GetNlmFont();
  65.     
  66.     // !?? static constructors for DParagraph should do all these !?
  67.     // fParaFmt = DParagraph();
  68.     fParaFmt.deftabstop = kDefTabstop;
  69.     // !?? static constructors for DParagraph should do all these !?
  70.     fOldParaFmt= fParaFmt;
  71.     fDefParaFmt= fParaFmt;
  72.  
  73.         // not for text types ?? (RTF should be ok w/ this...)
  74.     if (fDataFile) {
  75.         ulong fileindex;
  76.         fDataFile->GetDataMark( fileindex);
  77.         fDataFile->Open("rb"); // !!!!! DAMN TEXT TRANSLATION (0d to 0a) WAS SCREWING US UP !!
  78.         fDataFile->SetDataMark( fileindex);
  79.         }
  80. }
  81.  
  82.     
  83. DRichprocess::~DRichprocess()
  84. {
  85.     Close();
  86.     //if (fDataFile) fDataFile->Close(); // caller may do this?
  87.     MemFree(fText);
  88.     MemFree(fStyleArray);
  89.     MemFree(fTitle);
  90.     
  91. }
  92.  
  93. void DRichprocess::SetBuffer( char* dataBuffer, ulong dataSize, Boolean endOfData)
  94. {
  95.     fDataSize= dataSize;
  96.     if (dataSize) fDataBuffer= dataBuffer;
  97.     else fDataBuffer= NULL; // prevent GetOneChar trying to read when no data !
  98.     fEndOfData= endOfData;
  99. }
  100.  
  101. void DRichprocess::Read()
  102. {
  103.     while (GetToken() != tokEOF) 
  104.         RouteToken();
  105.     Close();
  106. }
  107.  
  108. void DRichprocess::Close()
  109. {
  110.     if (fTextSize>0) {
  111.         PutLitCharWithStyle('\n');
  112.         NewParagraph(); /* push last text into doc */
  113.         }
  114.     if (fProgress && fDataFile) {
  115.         long fat= fDataFile->Tell();
  116.         if (fat>0) (void) Nlm_MonitorIntValue(fProgress, fat);
  117.         }
  118. }
  119.  
  120.  
  121. short DRichprocess::GetOneChar()
  122. {
  123.     short    c;
  124.  
  125.     if (fDataBuffer) {
  126.         c= (unsigned char) *fDataBuffer; // must be unsigned !!
  127.         if (fDataSize) {    // for counted data
  128.             fDataSize--;
  129.             fDataBuffer++;
  130.             if (!fDataSize) fDataBuffer= NULL; //  so EOF next time
  131.             }
  132.         else if (c) fDataBuffer++; // for null-term data
  133.         else if (!fEndOfData) c= tokBreakInData;
  134.         else c= EOF;
  135.         }
  136.     else if (fDataFile) 
  137.         c = fgetc( fDataFile->fFile);
  138.     else {
  139.         if (!fEndOfData) c= tokBreakInData;
  140.         else c= EOF;
  141.         }
  142.     return (c);
  143. }
  144.  
  145.  
  146. void DRichprocess::Pushback(char c) // private
  147. {
  148.     if (c != EOF) {
  149.         fPushedChar = c;
  150.         }
  151. }
  152.  
  153.  
  154. void DRichprocess::RouteToken()
  155. {
  156.     switch( fClass ) {
  157.         case tokUnknown:  
  158.             handleUnknownClass(); 
  159.             break;
  160.         case tokText: 
  161.             handleTextClass(); 
  162.             break;
  163.         case tokControl:  
  164.             handleControlClass(); 
  165.             break;
  166.         default:
  167.             //RTFPanic ("Unknown class %d: %s ", fClass, fTokenBuf);
  168.             break;
  169.         }    
  170. }
  171.  
  172. short DRichprocess::GetToken()
  173. {
  174.     do GetToken1(); 
  175.     while (fClass == tokDropchar);
  176.     return (fClass);
  177. }
  178.  
  179.  
  180. void DRichprocess::GetToken1() // private
  181. {
  182.     short    c;
  183.     
  184.         /* initialize token vars */
  185.     fClass = tokUnknown;
  186.     fParam = tokNoParam;
  187.  
  188.         /* get first token character, which may be a pushback from previous token */
  189.     if (fPushedChar != EOF) {
  190.         c = fPushedChar;
  191.         fPushedChar = EOF;
  192.         }
  193.     else 
  194.         c= GetOneChar();
  195.          
  196.     switch ( c ) {
  197.     
  198.         case EOF:
  199.             fClass = tokEOF;
  200.             fMajor = 0;
  201.             return;
  202.         case tokBreakInData:
  203.             fClass= tokEOF;
  204.             fMajor= tokBreakInData;
  205.             return;
  206.             
  207.         case '\r': 
  208.         case '\n': //NEWLINE:
  209.             fClass = tokControl;
  210.             fMajor = tokNewline; //tokSpecialChar;
  211.             fMinor = c; //tokNewline;
  212.             return;
  213.              
  214.         default: 
  215.             fClass = tokText;
  216.             fMajor = c;
  217.             fMinor = c; // MapChar( c);
  218.             return; 
  219.             
  220.         }
  221. }
  222.  
  223.  
  224.  
  225. // static
  226. char* DRichprocess::gGenCharMap=  DRichprocess::ReadOutputMap("gen");
  227. char* DRichprocess::gSymCharMap=  DRichprocess::ReadOutputMap("sym");
  228.  
  229. char* DRichprocess::ReadOutputMap( char *file)
  230. {
  231. // from rtfmaps.h
  232. #ifdef WIN_MAC
  233. # define     genInMap  mac_gen_CharCode 
  234. # define     symInMap  mac_sym_CharCode 
  235. #else
  236. # define     genInMap  ansi_gen_CharCode 
  237. # define     symInMap  ansi_sym_CharCode 
  238. #endif
  239.     short *inMap, i, val;
  240.     char *outMap = (char*) MemNew( rtfSC_MaxChar*sizeof(char));
  241.     
  242.     if (*file == 's') inMap= symInMap;
  243.     else inMap= genInMap;
  244.  
  245.     for (i= 0; i<rtfSC_MaxChar; i++) outMap[i]= 0;
  246.     for (i= 255; i >= 0; i--) {
  247.         val= inMap[i];
  248.         if (val>=0 && val<rtfSC_MaxChar) outMap[val]= i;
  249.         }
  250.     return outMap;
  251. }
  252.  
  253.  
  254.  
  255. void DRichprocess::PutLitChar(short c)
  256. {
  257.     if (fTextSize >= fTextMax) {
  258.         fTextMax = fTextSize + 1024;
  259.         fText= (char*) MemMore( fText, fTextMax + 1);
  260.         }
  261.     fText[fTextSize++]= (char) c;
  262.     /* fText[fTextSize]= '\0'; */
  263. }
  264.  
  265. void DRichprocess::PutLitStr(char *s)
  266. {
  267.     long len = StrLen(s);
  268.     if (len + fTextSize >= fTextMax) {
  269.         fTextMax = fTextSize + len + 1024;
  270.         fText= (Nlm_CharPtr) MemMore( fText, fTextMax + 1);
  271.         }
  272.     Nlm_MemCopy( fText + fTextSize, s, len); /* +1 for nul */
  273.     fTextSize += len;
  274. }
  275.  
  276. void DRichprocess::PutLitCharWithStyle(short c)
  277. {
  278.     if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE);  
  279.     PutLitChar(c);
  280. }
  281.  
  282.  
  283.  
  284. void DRichprocess::PutStdChar( short stdCode)
  285. {
  286.     if (fOutMap) {
  287.         int och = fOutMap[stdCode];
  288.         if (och == rtfSC_nothing)    {  
  289.             char    buf[80];
  290.             sprintf(buf, "{{%s}}", RTFStdCharName(stdCode));
  291.             PutLitStr(buf);
  292.             }
  293.         else {
  294.             PutLitChar(och);
  295.             }
  296.         }
  297.     else {
  298.         PutLitChar(stdCode); 
  299.         }
  300. }
  301.  
  302.  
  303. void DRichprocess::PutStdCharWithStyle(short stdCode)
  304. {
  305.     if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE);  
  306.     PutStdChar(stdCode);
  307. }
  308.  
  309.  
  310. void DRichprocess::StoreStyle(DRichStyle& theStyle, Boolean force)
  311. {
  312.     if (force || fTextSize) {  
  313.         if (fStyleCount >= fStyleMax) {
  314.             fStyleMax  = fStyleCount + 10;
  315.             fStyleArray= (DRichStyle*) MemMore(fStyleArray, fStyleMax*sizeof(DRichStyle));
  316.             }
  317.     
  318.         theStyle.nextofs= fTextSize; //fLastTextSize;
  319.         //theStyle.textlen= fTextSize - fLastTextSize;
  320.         fLastTextSize= fTextSize;
  321.         if (!fFont) theStyle.font= GetNlmFont(); //x
  322.              
  323.         theStyle.last= FALSE; /* make sure... */
  324.         if (fStyleArray) fStyleArray[fStyleCount]= theStyle;
  325.         fStyleCount++; 
  326.          
  327.         //PutLitChar(chStyleTag);
  328.         }
  329.     fOldStyleRec= fStyleRec; /* gOldStyle= gStyle;  */
  330.     (void) GetNlmFont();          
  331.     NotNewStyle();
  332. }
  333.  
  334.  
  335. Boolean DRichprocess::IsNewStyle() 
  336. { 
  337. #if 1 //x
  338.     return fNewStyle; 
  339. #else
  340.     return TestNewStyle();
  341. #endif
  342. }
  343.  
  344. Boolean DRichprocess::TestNewStyle()
  345. {
  346.     fNewStyle = ( fOldStyleRec.fontname != fStyleRec.fontname 
  347.                     || fOldStyleRec.fontfamily != fStyleRec.fontfamily 
  348.                     || fOldStyleRec.fontsize != fStyleRec.fontsize 
  349.                     || fOldStyleRec.style.IsNotEqual( &fStyleRec.style)
  350.                     );
  351.     return fNewStyle;
  352. }
  353.  
  354.  
  355.  
  356. Nlm_FonT DRichprocess::GetNlmFont()
  357. {
  358. #if 1  //x
  359.         // GetFont is a time waster, cut down # of these calls !!
  360.     if (!fFont || IsNewStyle()) {
  361.         fFont= Nlm_GetFont( fStyleRec.fontname, fStyleRec.fontsize, 
  362.                     fStyleRec.style.bold, fStyleRec.style.italic, fStyleRec.style.underline != 0, 
  363.                     fStyleRec.fontfamily);
  364.         }
  365. #else
  366.         fFont= Nlm_GetFont( fStyleRec.fontname, fStyleRec.fontsize, 
  367.                     fStyleRec.style.bold, fStyleRec.style.italic, fStyleRec.style.underline != 0, 
  368.                     fStyleRec.fontfamily);
  369. #endif
  370.     fStyleRec.style.font= fFont;
  371.     fOldStyleRec= fStyleRec; 
  372.     NotNewStyle();
  373.     return fFont;
  374. }
  375.  
  376. void DRichprocess::PushStyle()
  377. {
  378.     if (fStyleStackSize<kMaxStyleStack) 
  379.         fStyleStack[fStyleStackSize++]= fStyleRec;
  380. }
  381.  
  382. void DRichprocess::PopStyle()
  383. {            
  384.     if (fStyleStackSize>0) 
  385.         fStyleRec= fStyleStack[--fStyleStackSize];
  386.     NewStyle();
  387. }
  388.  
  389.  
  390. void DRichprocess::DefaultParag()
  391. {
  392.     fParaFmt= fDefParaFmt;
  393. }
  394.  
  395. void DRichprocess::SetDefaultParag(DParagraph* theDefault)
  396. {
  397.     fDefParaFmt= *theDefault;
  398. }
  399.  
  400. void DRichprocess::DefaultStyle()
  401. {
  402.     fStyleRec= gDefaultStyle;
  403.     TestNewStyle();
  404. }
  405.  
  406.  
  407. void DRichprocess::NewParagraph()
  408. {
  409.     /* when new data forces use of new Dgg_ParData, 
  410.         append current text & para & col to growing doc */
  411. #if 1            
  412.     (void) GetNlmFont();  
  413.     StoreStyle( fStyleRec.style, TRUE);    /* gOldStyle */
  414.     //fTextSize--; /* unput last chStyleTag */
  415. #endif
  416.  
  417.     fStyleArray[fStyleCount-1].last= TRUE;
  418.     fText[fTextSize]= 0;
  419.     
  420.     fDoc->Append( fText, &fParaFmt, fStyleArray, fStyleCount);
  421.  
  422.     if (fProgress && fDataFile && (fParaCount % 10 == 0)) 
  423.         (void) Nlm_MonitorIntValue(fProgress, fDataFile->Tell());
  424.     fParaCount++;
  425.     fOldParaFmt= fParaFmt;
  426.     fParaFmt.numstops= fTextSize= fLastTextSize= fStyleCount= 0;
  427. }
  428.  
  429.  
  430.  
  431.  
  432.  
  433. void DRichprocess::handleUnknownClass()
  434. {
  435.     // nothing
  436. }
  437.  
  438. void DRichprocess::handleTextClass()
  439. {
  440.     if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE);  
  441.     PutLitChar(fMinor); 
  442.     fLastChar= fMajor;
  443. }
  444.  
  445. void DRichprocess::handleControlClass()
  446. {
  447.     switch (fMajor) {
  448.         
  449.         case tokNewline:
  450.             PutLitCharWithStyle ('\n');
  451.             NewParagraph();
  452.             break;
  453.  
  454.         default:
  455.             break;
  456.         }
  457.  
  458. }
  459.  
  460.  
  461.